Integratietesten: Beheers API-testen met Supertest

In de wereld van softwareontwikkeling is het cruciaal om ervoor te zorgen dat individuele componenten afzonderlijk correct functioneren (unit testing). Het is echter even belangrijk om te verifiëren dat deze componenten naadloos samenwerken. Hier komt integratietesten om de hoek kijken. Integratietesten richt zich op het valideren van de interactie tussen verschillende modules of services binnen een applicatie. Dit artikel duikt diep in integratietesten, met een specifieke focus op API-testen met Supertest, een krachtige en gebruiksvriendelijke bibliotheek voor het testen van HTTP-assertions in Node.js.

Wat is Integratietesten?

Integratietesten is een type softwaretesten waarbij individuele softwaremodules worden gecombineerd en als groep worden getest. Het doel is om defecten in de interacties tussen geïntegreerde eenheden aan het licht te brengen. In tegenstelling tot unit testing, dat zich richt op individuele componenten, verifieert integratietesten de data- en controlestroom tussen modules. Veelvoorkomende benaderingen voor integratietesten zijn:

• Top-down integratie: Beginnen met de modules op het hoogste niveau en naar beneden integreren.
• Bottom-up integratie: Beginnen met de modules op het laagste niveau en naar boven integreren.
• Big-bang integratie: Alle modules tegelijkertijd integreren. Deze aanpak wordt over het algemeen minder aanbevolen vanwege de moeilijkheid om problemen te isoleren.
• Sandwich integratie: Een combinatie van top-down en bottom-up integratie.

In de context van API's omvat integratietesten het verifiëren dat verschillende API's correct samenwerken, dat de gegevens die tussen hen worden doorgegeven consistent zijn, en dat het algehele systeem functioneert zoals verwacht. Stel je bijvoorbeeld een e-commerce applicatie voor met afzonderlijke API's voor productbeheer, gebruikersauthenticatie en betalingsverwerking. Integratietesten zou ervoor zorgen dat deze API's correct communiceren, zodat gebruikers producten kunnen bekijken, veilig kunnen inloggen en aankopen kunnen voltooien.

Waarom is API-integratietesten Belangrijk?

API-integratietesten is om verschillende redenen cruciaal:

• Zorgt voor Systeembetrouwbaarheid: Het helpt integratieproblemen vroeg in de ontwikkelingscyclus te identificeren, waardoor onverwachte storingen in productie worden voorkomen.
• Valideert Data-integriteit: Het verifieert dat gegevens correct worden verzonden en getransformeerd tussen verschillende API's.
• Verbetert Applicatieprestaties: Het kan prestatieknelpunten met betrekking tot API-interacties aan het licht brengen.
• Verhoogt de Veiligheid: Het kan beveiligingskwetsbaarheden identificeren die voortkomen uit onjuiste API-integratie. Bijvoorbeeld, het waarborgen van de juiste authenticatie en autorisatie wanneer API's communiceren.
• Verlaagt Ontwikkelingskosten: Het vroegtijdig oplossen van integratieproblemen is aanzienlijk goedkoper dan ze later in de ontwikkelingslevenscyclus aan te pakken.

Neem een wereldwijd reisboekingsplatform. API-integratietesten is van het grootste belang om een soepele communicatie te garanderen tussen API's die vluchtreserveringen, hotelboekingen en betalingsgateways uit verschillende landen afhandelen. Het niet correct integreren van deze API's kan leiden tot onjuiste boekingen, betalingsfouten en een slechte gebruikerservaring, wat de reputatie en omzet van het platform negatief beïnvloedt.

Introductie van Supertest: Een Krachtige Tool voor API-testen

Supertest is een high-level abstractie voor het testen van HTTP-requests. Het biedt een handige en vloeiende API voor het verzenden van requests naar je applicatie en het doen van assertions op de responses. Supertest is gebouwd bovenop Node.js en is specifiek ontworpen voor het testen van Node.js HTTP-servers. Het werkt uitzonderlijk goed met populaire testframeworks zoals Jest en Mocha.

Belangrijkste Kenmerken van Supertest:

• Eenvoudig in Gebruik: Supertest biedt een simpele en intuïtieve API voor het versturen van HTTP-requests en het maken van assertions.
• Asynchroon Testen: Het handelt naadloos asynchrone operaties af, wat het ideaal maakt voor het testen van API's die afhankelijk zijn van asynchrone logica.
• Vloeiende Interface: Het biedt een vloeiende interface, waardoor je methoden aan elkaar kunt ketenen voor beknopte en leesbare tests.
• Uitgebreide Assertion-ondersteuning: Het ondersteunt een breed scala aan assertions voor het verifiëren van response statuscodes, headers en bodies.
• Integratie met Testframeworks: Het integreert naadloos met populaire testframeworks zoals Jest en Mocha, waardoor je je bestaande testinfrastructuur kunt gebruiken.

Het Opzetten van je Testomgeving

Voordat we beginnen, laten we een basis testomgeving opzetten. We gaan ervan uit dat je Node.js en npm (of yarn) hebt geïnstalleerd. We gebruiken Jest als ons testframework en Supertest voor API-testen.

1. Maak een Node.js-project aan:

            mkdir api-testing-example
cd api-testing-example
npm init -y
            

              
                Copy
              
            
          

2. Installeer afhankelijkheden:

            npm install --save-dev jest supertest
npm install express  # Of je favoriete framework voor het maken van de API
            

              
                Copy
              
            
          

3. Configureer Jest: Voeg het volgende toe aan je package.json-bestand:

            {
  "scripts": {
    "test": "jest"
  }
}
            

              
                Copy
              
            
          

4. Maak een eenvoudig API-eindpunt: Maak een bestand genaamd app.js (of vergelijkbaar) met de volgende code:

            const express = require('express');
const app = express();
const port = 3000;

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

module.exports = app; // Exporteer voor het testen

            

              
                Copy
              
            
          

Je Eerste Supertest-test Schrijven

Nu we onze omgeving hebben opgezet, laten we een eenvoudige Supertest-test schrijven om ons API-eindpunt te verifiëren. Maak een bestand genaamd app.test.js (of vergelijkbaar) in de root van je project:

            const request = require('supertest');
const app = require('./app');

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

            

              
                Copy
              
            
          

Uitleg:

• We importeren supertest en onze Express-app.
• We gebruiken describe om onze tests te groeperen.
• We gebruiken it om een specifieke testcase te definiëren.
• We gebruiken request(app) om een Supertest-agent te maken die requests naar onze app zal sturen.
• We gebruiken .get('/hello') om een GET-request naar het /hello-eindpunt te sturen.
• We gebruiken await om op de response te wachten. De methoden van Supertest retourneren promises, waardoor we async/await kunnen gebruiken voor schonere code.
• We gebruiken expect(response.statusCode).toBe(200) om te controleren of de response statuscode 200 OK is.
• We gebruiken expect(response.text).toBe('Hello, World!') om te controleren of de response body "Hello, World!" is.

Om de test uit te voeren, voer je het volgende commando uit in je terminal:

            npm test
            

              
                Copy
              
            
          

Als alles correct is ingesteld, zou je de test moeten zien slagen.

Geavanceerde Supertest-technieken

Supertest biedt een breed scala aan functies voor geavanceerd API-testen. Laten we er een paar verkennen.

1. Request Bodies Verzenden

Om gegevens in de request body te verzenden, kun je de .send()-methode gebruiken. Laten we bijvoorbeeld een eindpunt maken dat JSON-data accepteert:

            app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Simuleer het aanmaken van een gebruiker in een database
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});
            

              
                Copy
              
            
          

Zo kun je dit eindpunt testen met Supertest:

            describe('POST /users', () => {
  it('creates a new user', async () => {
    const userData = {
      name: 'John Doe',
      email: 'john.doe@example.com',
    };

    const response = await request(app)
      .post('/users')
      .send(userData)
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe(userData.name);
    expect(response.body.email).toBe(userData.email);
  });
});
            

              
                Copy
              
            
          

Uitleg:

• We gebruiken .post('/users') om een POST-request naar het /users-eindpunt te sturen.
• We gebruiken .send(userData) om het userData-object in de request body te sturen. Supertest stelt automatisch de Content-Type-header in op application/json.
• We gebruiken .expect(201) om te controleren of de response statuscode 201 Created is.
• We gebruiken expect(response.body).toHaveProperty('id') om te controleren of de response body een id-eigenschap bevat.
• We gebruiken expect(response.body.name).toBe(userData.name) en expect(response.body.email).toBe(userData.email) om te controleren of de name- en email-eigenschappen in de response body overeenkomen met de gegevens die we in de request hebben verzonden.

2. Headers Instellen

Om aangepaste headers in je requests in te stellen, kun je de .set()-methode gebruiken. Dit is handig voor het instellen van authenticatietokens, content types of andere aangepaste headers.

            describe('GET /protected', () => {
  it('requires authentication', async () => {
    const response = await request(app).get('/protected').expect(401);
  });

  it('returns 200 OK with a valid token', async () => {
    // Simuleer het verkrijgen van een geldig token
    const token = 'valid-token';

    const response = await request(app)
      .get('/protected')
      .set('Authorization', `Bearer ${token}`)
      .expect(200);

    expect(response.text).toBe('Protected Resource');
  });
});
            

              
                Copy
              
            
          

Uitleg:

• We gebruiken .set('Authorization', `Bearer ${token}`) om de Authorization-header in te stellen op Bearer ${token}.

3. Omgaan met Cookies

Supertest kan ook omgaan met cookies. Je kunt cookies instellen met de .set('Cookie', ...)-methode, of je kunt de .cookies-eigenschap gebruiken om cookies te openen en aan te passen.

4. Testen van File Uploads

Supertest kan worden gebruikt om API-eindpunten te testen die file uploads afhandelen. Je kunt de .attach()-methode gebruiken om bestanden aan de request te koppelen.

5. Gebruik van Assertion-bibliotheken (Chai)

Hoewel de ingebouwde assertion-bibliotheek van Jest in veel gevallen volstaat, kun je ook krachtigere assertion-bibliotheken zoals Chai met Supertest gebruiken. Chai biedt een expressievere en flexibelere assertion-syntaxis. Om Chai te gebruiken, moet je het installeren:

            npm install --save-dev chai
            

              
                Copy
              
            
          

Vervolgens kun je Chai in je testbestand importeren en de assertions gebruiken:

            const request = require('supertest');
const app = require('./app');
const chai = require('chai');
const expect = chai.expect;

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});
            

              
                Copy
              
            
          

Let op: Mogelijk moet je Jest configureren om correct met Chai te werken. Dit houdt vaak in dat je een setup-bestand toevoegt dat Chai importeert en configureert om te werken met de globale expect van Jest.

6. Hergebruiken van Agents

Voor tests die een specifieke omgeving vereisen (bijv. authenticatie), is het vaak voordelig om een Supertest-agent te hergebruiken. Dit voorkomt overbodige setup-code in elke testcase.

            describe('Authenticated API Tests', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Maak een persistente agent
    // Simuleer authenticatie
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('can access a protected resource', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('can perform other actions that require authentication', async () => {
    // Voer hier andere geauthenticeerde acties uit
  });
});
            

              
                Copy
              
            
          

In dit voorbeeld maken we een Supertest-agent aan in de beforeAll-hook en authenticeren we de agent. Opeenvolgende tests binnen het describe-blok kunnen deze geauthenticeerde agent vervolgens hergebruiken zonder voor elke test opnieuw te hoeven authenticeren.

Best Practices voor API-integratietesten met Supertest

Om effectieve API-integratietesten te garanderen, overweeg de volgende best practices:

• Test End-to-End Workflows: Richt je op het testen van complete gebruikersworkflows in plaats van geïsoleerde API-eindpunten. Dit helpt bij het identificeren van integratieproblemen die mogelijk niet zichtbaar zijn bij het afzonderlijk testen van individuele API's.
• Gebruik Realistische Data: Gebruik realistische data in je tests om praktijkscenario's te simuleren. Dit omvat het gebruik van geldige dataformaten, grenswaarden en mogelijk ongeldige data om de foutafhandeling te testen.
• Isoleer je Tests: Zorg ervoor dat je tests onafhankelijk van elkaar zijn en niet afhankelijk zijn van een gedeelde staat. Dit maakt je tests betrouwbaarder en makkelijker te debuggen. Overweeg het gebruik van een aparte testdatabase of het mocken van externe afhankelijkheden.
• Mock Externe Afhankelijkheden: Gebruik mocking om je API te isoleren van externe afhankelijkheden, zoals databases, API's van derden of andere services. Dit maakt je tests sneller en betrouwbaarder, en het stelt je ook in staat om verschillende scenario's te testen zonder afhankelijk te zijn van de beschikbaarheid van externe services. Bibliotheken zoals nock zijn handig voor het mocken van HTTP-requests.
• Schrijf Uitgebreide Tests: Streef naar een uitgebreide testdekking, inclusief positieve tests (het verifiëren van succesvolle responses), negatieve tests (het verifiëren van foutafhandeling) en grenswaarde-tests (het verifiëren van edge cases).
• Automatiseer je Tests: Integreer je API-integratietests in je continuous integration (CI) pipeline om ervoor te zorgen dat ze automatisch worden uitgevoerd wanneer er wijzigingen in de codebase worden aangebracht. Dit helpt om integratieproblemen vroegtijdig te identificeren en te voorkomen dat ze productie bereiken.
• Documenteer je Tests: Documenteer je API-integratietests duidelijk en beknopt. Dit maakt het voor andere ontwikkelaars gemakkelijker om het doel van de tests te begrijpen en ze in de loop van de tijd te onderhouden.
• Gebruik Omgevingsvariabelen: Sla gevoelige informatie zoals API-sleutels, databasewachtwoorden en andere configuratiewaarden op in omgevingsvariabelen in plaats van ze hard te coderen in je tests. Dit maakt je tests veiliger en gemakkelijker te configureren voor verschillende omgevingen.
• Overweeg API-contracten: Maak gebruik van API-contracttesten om te valideren dat je API zich houdt aan een gedefinieerd contract (bijv. OpenAPI/Swagger). Dit helpt de compatibiliteit tussen verschillende services te garanderen en voorkomt 'breaking changes'. Tools zoals Pact kunnen worden gebruikt voor contracttesten.

Veelvoorkomende Fouten om te Vermijden

• Tests niet isoleren: Tests moeten onafhankelijk zijn. Vermijd afhankelijkheid van de uitkomst van andere tests.
• Implementatiedetails testen: Focus op het gedrag en het contract van de API, niet op de interne implementatie.
• Foutafhandeling negeren: Test grondig hoe je API omgaat met ongeldige invoer, edge cases en onverwachte fouten.
• Authenticatie- en autorisatietests overslaan: Zorg ervoor dat de beveiligingsmechanismen van je API correct worden getest om ongeautoriseerde toegang te voorkomen.

Conclusie

API-integratietesten is een essentieel onderdeel van het softwareontwikkelingsproces. Door Supertest te gebruiken, kun je eenvoudig uitgebreide en betrouwbare API-integratietests schrijven die helpen de kwaliteit en stabiliteit van je applicatie te waarborgen. Onthoud dat je je moet richten op het testen van end-to-end workflows, het gebruik van realistische data, het isoleren van je tests en het automatiseren van je testproces. Door deze best practices te volgen, kun je het risico op integratieproblemen aanzienlijk verminderen en een robuuster en betrouwbaarder product leveren.

Aangezien API's moderne applicaties en microservices-architecturen blijven aansturen, zal het belang van robuust API-testen, en met name integratietesten, alleen maar toenemen. Supertest biedt een krachtige en toegankelijke toolset voor ontwikkelaars wereldwijd om de betrouwbaarheid en kwaliteit van hun API-interacties te waarborgen.